
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Web.Services;
    using HER;
    using AEL.BOD;
    using BEL;
    using CEL.BOD;
  namespace EWS
  {
  /// <summary>
  /// Summary description for WS_BOD
  /// </summary>
  [WebService(Namespace = "http://koala.org/")]
  [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
  [ToolboxItem(false)]
  public class WS_BOD : WebService
  {
   // Posible problema con static y nuevas consultas a la base
   // se debería optimizar la llamada a los objeto DO, 
  // para que esté creado desde el momento de la llamada
   // o
  // que problema existe en concurrencia??
    #region Servicios para Bod_Atributo
    // Objeto permanente para acceso a DO_Bod_Atributo
    private DO_Bod_Atributo _Bod_Atributo ;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Atributo
    /// </summary>
    public DO_Bod_Atributo Bod_Atributo
    {
    get
    {
    if(_Bod_Atributo == null)
    _Bod_Atributo = new DO_Bod_Atributo ();
    return _Bod_Atributo ;
    }
    }
    
    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Atributo> Bod_Atributo_Get(Scope s)
    {
     return Bod_Atributo.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Atributo
    /// </summary>
    /// <returns>Todos los registros de Bod_Atributo </returns>
    
        [WebMethod]
        public List< Bod_Atributo> Bod_Atributo_GetByCodigo ( Scope s, string Codigo)
        {
        return Bod_Atributo.GetByCodigo(s, Codigo );
        }
        [WebMethod]
        public List< Bod_Atributo> Bod_Atributo_GetByEmpresa ( Scope s)
        {
        return Bod_Atributo.GetByEmpresa(s);
        }
        [WebMethod]
        public List< Bod_Atributo> Bod_Atributo_GetById ( Scope s, string Id)
        {
        return Bod_Atributo.GetById(s, Id );
        }
        [WebMethod]
        public List< Bod_Atributo> Bod_Atributo_GetByLikeNombre ( Scope s, string Nombre)
        {
        return Bod_Atributo.GetByLikeNombre(s, Nombre );
        }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Atributo
    /// <summary>
    /// Borra el objeto de Bod_Atributo
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Atributo_Delete(Scope s, Bod_Atributo o)
    {
    try
    {
    return Bod_Atributo.Delete(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Atributo
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Atributo_Insert(Scope s, Bod_Atributo o)
    {
    try
    {
    return Bod_Atributo.Insert(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Atributo
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Atributo_Update (Scope s, Bod_Atributo o, Bod_Atributo original)
    {
    try
    {
    return Bod_Atributo.Update(s,o,original);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    #endregion
    #endregion
    
    #region Servicios para Bod_Bodega
    // Objeto permanente para acceso a DO_Bod_Bodega
    private DO_Bod_Bodega _Bod_Bodega ;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Bodega
    /// </summary>
    public DO_Bod_Bodega Bod_Bodega
    {
    get
    {
    if(_Bod_Bodega == null)
    _Bod_Bodega = new DO_Bod_Bodega ();
    return _Bod_Bodega ;
    }
    }
    
    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Bodega> Bod_Bodega_Get(Scope s)
    {
     return Bod_Bodega.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Bodega
    /// </summary>
    /// <returns>Todos los registros de Bod_Bodega </returns>
    
        [WebMethod]
        public List< Bod_Bodega> Bod_Bodega_GetByCodigo ( Scope s, string Codigo)
        {
        return Bod_Bodega.GetByCodigo(s, Codigo );
        }
        [WebMethod]
        public List< Bod_Bodega> Bod_Bodega_GetByEmpresa ( Scope s)
        {
        return Bod_Bodega.GetByEmpresa(s);
        }
        [WebMethod]
        public List< Bod_Bodega> Bod_Bodega_GetById ( Scope s, string Id)
        {
        return Bod_Bodega.GetById(s, Id );
        }
        [WebMethod]
        public List<Bod_Bodega> Bod_Bodega_GetByLikeNombre(Scope s, string Nombre)
        {
          return Bod_Bodega.GetByLikeNombre(s, Nombre);
        }
        [WebMethod]
        public List<Bod_Bodega> Bod_Bodega_GetByLikeNombreAll(Scope s, string Nombre)
        {
          return Bod_Bodega.GetByLikeNombreAll(s, Nombre);
        }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Bodega
    /// <summary>
    /// Borra el objeto de Bod_Bodega
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Bodega_Delete(Scope s, Bod_Bodega o)
    {
    try
    {
    return Bod_Bodega.Delete(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Bodega
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Bodega_Insert(Scope s, Bod_Bodega o)
    {
    try
    {
    return Bod_Bodega.Insert(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Bodega
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Bodega_Update (Scope s, Bod_Bodega o, Bod_Bodega original)
    {
    try
    {
    return Bod_Bodega.Update(s,o,original);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    #endregion
    #endregion
    
    #region Servicios para Bod_Clase
    // Objeto permanente para acceso a DO_Bod_Clase
    private DO_Bod_Clase _Bod_Clase ;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Clase
    /// </summary>
    public DO_Bod_Clase Bod_Clase
    {
    get
    {
    if(_Bod_Clase == null)
    _Bod_Clase = new DO_Bod_Clase ();
    return _Bod_Clase ;
    }
    }
    
    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Clase> Bod_Clase_Get(Scope s)
    {
     return Bod_Clase.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Clase
    /// </summary>
    /// <returns>Todos los registros de Bod_Clase </returns>
    
        [WebMethod]
        public List< Bod_Clase> Bod_Clase_GetByCodigo ( Scope s, string Codigo)
        {
        return Bod_Clase.GetByCodigo(s, Codigo );
        }
        [WebMethod]
        public List< Bod_Clase> Bod_Clase_GetByEmpresa ( Scope s)
        {
        return Bod_Clase.GetByEmpresa(s);
        }
        [WebMethod]
        public List< Bod_Clase> Bod_Clase_GetById ( Scope s, string Id)
        {
        return Bod_Clase.GetById(s, Id );
        }
        [WebMethod]
        public List<Bod_Clase> Bod_Clase_GetByLikeNombre(Scope s, string Nombre)
        {
          return Bod_Clase.GetByLikeNombre(s, Nombre);
        }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Clase
    /// <summary>
    /// Borra el objeto de Bod_Clase
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Clase_Delete(Scope s, Bod_Clase o)
    {
    try
    {
    return Bod_Clase.Delete(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Clase
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Clase_Insert(Scope s, Bod_Clase o)
    {
    try
    {
    return Bod_Clase.Insert(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Clase
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Clase_Update (Scope s, Bod_Clase o, Bod_Clase original)
    {
    try
    {
    return Bod_Clase.Update(s,o,original);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    #endregion
    #endregion
    
    #region Servicios para Bod_Clase_Atributo
    // Objeto permanente para acceso a DO_Bod_Clase_Atributo
    private DO_Bod_Clase_Atributo _Bod_Clase_Atributo ;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Clase_Atributo
    /// </summary>
    public DO_Bod_Clase_Atributo Bod_Clase_Atributo
    {
    get
    {
    if(_Bod_Clase_Atributo == null)
    _Bod_Clase_Atributo = new DO_Bod_Clase_Atributo ();
    return _Bod_Clase_Atributo ;
    }
    }
    
    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Clase_Atributo> Bod_Clase_Atributo_Get(Scope s)
    {
     return Bod_Clase_Atributo.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Clase_Atributo
    /// </summary>
    /// <returns>Todos los registros de Bod_Clase_Atributo </returns>
    
        [WebMethod]
        public List< Bod_Clase_Atributo> Bod_Clase_Atributo_GetByClase ( Scope s, string Bod_Clase_Id)
        {
        return Bod_Clase_Atributo.GetByClase(s, Bod_Clase_Id );
        }
        [WebMethod]
        public List< Bod_Clase_Atributo> Bod_Clase_Atributo_GetByCodigo ( Scope s, string Codigo)
        {
        return Bod_Clase_Atributo.GetByCodigo(s, Codigo );
        }
        [WebMethod]
        public List< Bod_Clase_Atributo> Bod_Clase_Atributo_GetById ( Scope s, string Id)
        {
        return Bod_Clase_Atributo.GetById(s, Id );
        }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Clase_Atributo
    /// <summary>
    /// Borra el objeto de Bod_Clase_Atributo
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Clase_Atributo_Delete(Scope s, Bod_Clase_Atributo o)
    {
    try
    {
    return Bod_Clase_Atributo.Delete(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Clase_Atributo
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Clase_Atributo_Insert(Scope s, Bod_Clase_Atributo o)
    {
    try
    {
    return Bod_Clase_Atributo.Insert(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Clase_Atributo
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Clase_Atributo_Update (Scope s, Bod_Clase_Atributo o, Bod_Clase_Atributo original)
    {
    try
    {
    return Bod_Clase_Atributo.Update(s,o,original);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    #endregion
    #endregion
    
    #region Servicios para Bod_Grupo
    // Objeto permanente para acceso a DO_Bod_Grupo
    private DO_Bod_Grupo _Bod_Grupo ;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Grupo
    /// </summary>
    public DO_Bod_Grupo Bod_Grupo
    {
    get
    {
    if(_Bod_Grupo == null)
    _Bod_Grupo = new DO_Bod_Grupo ();
    return _Bod_Grupo ;
    }
    }
    
    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Grupo> Bod_Grupo_Get(Scope s)
    {
     return Bod_Grupo.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Grupo
    /// </summary>
    /// <returns>Todos los registros de Bod_Grupo </returns>
    
        [WebMethod]
        public List< Bod_Grupo> Bod_Grupo_GetByCodigo ( Scope s, string Codigo)
        {
        return Bod_Grupo.GetByCodigo(s, Codigo );
        }
        [WebMethod]
        public List< Bod_Grupo> Bod_Grupo_GetByEmpresa ( Scope s)
        {
        return Bod_Grupo.GetByEmpresa(s);
        }
        [WebMethod]
        public List< Bod_Grupo> Bod_Grupo_GetById ( Scope s, string Id)
        {
        return Bod_Grupo.GetById(s, Id );
        }
        [WebMethod]
        public List<Bod_Grupo> Bod_Grupo_GetByLikeNombre(Scope s, string Nombre)
        {
        return Bod_Grupo.GetByLikeNombre(s, Nombre);
        }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Grupo
    /// <summary>
    /// Borra el objeto de Bod_Grupo
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Grupo_Delete(Scope s, Bod_Grupo o)
    {
    try
    {
    return Bod_Grupo.Delete(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Grupo
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Grupo_Insert(Scope s, Bod_Grupo o)
    {
    try
    {
    return Bod_Grupo.Insert(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Grupo
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Grupo_Update (Scope s, Bod_Grupo o, Bod_Grupo original)
    {
    try
    {
    return Bod_Grupo.Update(s,o,original);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    #endregion
    #endregion
    
    #region Servicios para Bod_Bodega_Personal
    // Objeto permanente para acceso a DO_Bod_Bodega_Personal
    private DO_Bod_Bodega_Personal _Bod_Bodega_Personal ;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Bodega_Personal
    /// </summary>
    public DO_Bod_Bodega_Personal Bod_Bodega_Personal
    {
    get
    {
    if(_Bod_Bodega_Personal == null)
    _Bod_Bodega_Personal = new DO_Bod_Bodega_Personal ();
    return _Bod_Bodega_Personal ;
    }
    }
    
    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Bodega_Personal> Bod_Bodega_Personal_Get(Scope s)
    {
     return Bod_Bodega_Personal.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Bodega_Personal
    /// </summary>
    /// <returns>Todos los registros de Bod_Bodega_Personal </returns>
    
        [WebMethod]
        public List< Bod_Bodega_Personal> Bod_Bodega_Personal_GetByBodega ( Scope s, string Bod_Bodega_Id)
        {
        return Bod_Bodega_Personal.GetByBodega(s, Bod_Bodega_Id );
        }
        [WebMethod]
        public List< Bod_Bodega_Personal> Bod_Bodega_Personal_GetByCodigo ( Scope s, string Codigo)
        {
        return Bod_Bodega_Personal.GetByCodigo(s, Codigo );
        }
        [WebMethod]
        public List< Bod_Bodega_Personal> Bod_Bodega_Personal_GetById ( Scope s, string Id)
        {
        return Bod_Bodega_Personal.GetById(s, Id );
        }
        [WebMethod]
        public List<Bod_Bodega_Personal> Bod_Bodega_Personal_GetByBodegaPersonal(Scope s, string Bod_Bodega_Id)
        {
        return Bod_Bodega_Personal.GetByBodegaPersonal(s,Bod_Bodega_Id);
        } 
    #endregion
    #region  Operaciones con datos de la tabla Bod_Bodega_Personal
    /// <summary>
    /// Borra el objeto de Bod_Bodega_Personal
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Bodega_Personal_Delete(Scope s, Bod_Bodega_Personal o)
    {
    try
    {
    return Bod_Bodega_Personal.Delete(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Bodega_Personal
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Bodega_Personal_Insert(Scope s, Bod_Bodega_Personal o)
    {
    try
    {
    return Bod_Bodega_Personal.Insert(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Bodega_Personal
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Bodega_Personal_Update (Scope s, Bod_Bodega_Personal o, Bod_Bodega_Personal original)
    {
    try
    {
    return Bod_Bodega_Personal.Update(s,o,original);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    #endregion
    #endregion
    
    #region Servicios para Bod_Bodega_Tipo
    // Objeto permanente para acceso a DO_Bod_Bodega_Tipo
    private DO_Bod_Bodega_Tipo _Bod_Bodega_Tipo ;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Bodega_Tipo
    /// </summary>
    public DO_Bod_Bodega_Tipo Bod_Bodega_Tipo
    {
    get
    {
    if(_Bod_Bodega_Tipo == null)
    _Bod_Bodega_Tipo = new DO_Bod_Bodega_Tipo ();
    return _Bod_Bodega_Tipo ;
    }
    }
    
    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Bodega_Tipo> Bod_Bodega_Tipo_Get(Scope s)
    {
     return Bod_Bodega_Tipo.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Bodega_Tipo
    /// </summary>
    /// <returns>Todos los registros de Bod_Bodega_Tipo </returns>
    
        [WebMethod]
        public List< Bod_Bodega_Tipo> Bod_Bodega_Tipo_GetByCodigo ( Scope s, string Codigo)
        {
        return Bod_Bodega_Tipo.GetByCodigo(s, Codigo );
        }
        [WebMethod]
        public List< Bod_Bodega_Tipo> Bod_Bodega_Tipo_GetByEmpresa ( Scope s)
        {
        return Bod_Bodega_Tipo.GetByEmpresa(s);
        }
        [WebMethod]
        public List< Bod_Bodega_Tipo> Bod_Bodega_Tipo_GetById ( Scope s, string Id)
        {
        return Bod_Bodega_Tipo.GetById(s, Id );
        }
        [WebMethod]
        public List< Bod_Bodega_Tipo> Bod_Bodega_Tipo_GetByLikeNombre ( Scope s, string Nombre)
        {
        return Bod_Bodega_Tipo.GetByLikeNombre(s, Nombre );
        }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Bodega_Tipo
    /// <summary>
    /// Borra el objeto de Bod_Bodega_Tipo
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Bodega_Tipo_Delete(Scope s, Bod_Bodega_Tipo o)
    {
    try
    {
    return Bod_Bodega_Tipo.Delete(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Bodega_Tipo
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Bodega_Tipo_Insert(Scope s, Bod_Bodega_Tipo o)
    {
    try
    {
    return Bod_Bodega_Tipo.Insert(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Bodega_Tipo
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Bodega_Tipo_Update (Scope s, Bod_Bodega_Tipo o, Bod_Bodega_Tipo original)
    {
    try
    {
    return Bod_Bodega_Tipo.Update(s,o,original);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Articulo_Atributo
    // Objeto permanente para acceso a DO_Bod_Articulo_Atributo
    private DO_Bod_Articulo_Atributo _Bod_Articulo_Atributo;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Articulo_Atributo
    /// </summary>
    public DO_Bod_Articulo_Atributo Bod_Articulo_Atributo
    {
        get
        {
            if (_Bod_Articulo_Atributo == null)
                _Bod_Articulo_Atributo = new DO_Bod_Articulo_Atributo();
            return _Bod_Articulo_Atributo;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Articulo_Atributo> Bod_Articulo_Atributo_Get(Scope s)
    {
        return Bod_Articulo_Atributo.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Articulo_Atributo
    /// </summary>
    /// <returns>Todos los registros de Bod_Articulo_Atributo </returns>

    [WebMethod]
    public List<Bod_Articulo_Atributo> Bod_Articulo_Atributo_GetByArticulo(Scope s, string Bod_Articulo_Id)
    {
        return Bod_Articulo_Atributo.GetByArticulo(s, Bod_Articulo_Id);
    }
    [WebMethod]
    public List<Bod_Articulo_Atributo> Bod_Articulo_Atributo_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Articulo_Atributo.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Articulo_Atributo> Bod_Articulo_Atributo_GetById(Scope s, string Id)
    {
        return Bod_Articulo_Atributo.GetById(s, Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Articulo_Atributo
    /// <summary>
    /// Borra el objeto de Bod_Articulo_Atributo
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Articulo_Atributo_Delete(Scope s, Bod_Articulo_Atributo o)
    {
        try
        {
            return Bod_Articulo_Atributo.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Articulo_Atributo
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Articulo_Atributo_Insert(Scope s, Bod_Articulo_Atributo o)
    {
        try
        {
            return Bod_Articulo_Atributo.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Articulo_Atributo
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Articulo_Atributo_Update(Scope s, Bod_Articulo_Atributo o, Bod_Articulo_Atributo original)
    {
        try
        {
            return Bod_Articulo_Atributo.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Articulo
    // Objeto permanente para acceso a DO_Bod_Articulo
    private DO_Bod_Articulo _Bod_Articulo;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Articulo
    /// </summary>
    public DO_Bod_Articulo Bod_Articulo
    {
        get
        {
            if (_Bod_Articulo == null)
                _Bod_Articulo = new DO_Bod_Articulo();
            return _Bod_Articulo;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Articulo> Bod_Articulo_Get(Scope s)
    {
        return Bod_Articulo.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Articulo
    /// </summary>
    /// <returns>Todos los registros de Bod_Articulo </returns>

    [WebMethod]
    public List<Bod_Articulo> Bod_Articulo_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Articulo.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Articulo> Bod_Articulo_GetByEmpresa(Scope s)
    {
        return Bod_Articulo.GetByEmpresa(s);
    }
    [WebMethod]
    public List<Bod_Articulo> Bod_Articulo_GetById(Scope s, string Id)
    {
        return Bod_Articulo.GetById(s, Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Articulo
    /// <summary>
    /// Borra el objeto de Bod_Articulo
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Articulo_Delete(Scope s, Bod_Articulo o)
    {
        try
        {
            return Bod_Articulo.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Articulo
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Articulo_Insert(Scope s, Bod_Articulo o)
    {
        try
        {
            return Bod_Articulo.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Articulo
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Articulo_Update(Scope s, Bod_Articulo o, Bod_Articulo original)
    {
        try
        {
            return Bod_Articulo.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Unidad
    // Objeto permanente para acceso a DO_Bod_Unidad
    private DO_Bod_Unidad _Bod_Unidad;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Unidad
    /// </summary>
    public DO_Bod_Unidad Bod_Unidad
    {
        get
        {
            if (_Bod_Unidad == null)
                _Bod_Unidad = new DO_Bod_Unidad();
            return _Bod_Unidad;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Unidad> Bod_Unidad_Get(Scope s)
    {
        return Bod_Unidad.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Unidad
    /// </summary>
    /// <returns>Todos los registros de Bod_Unidad </returns>

    [WebMethod]
    public List<Bod_Unidad> Bod_Unidad_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Unidad.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Unidad> Bod_Unidad_GetByEmpresa(Scope s)
    {
        return Bod_Unidad.GetByEmpresa(s);
    }
    [WebMethod]
    public List<Bod_Unidad> Bod_Unidad_GetById(Scope s, string Id)
    {
        return Bod_Unidad.GetById(s, Id);
    }
    [WebMethod]
    public List<Bod_Unidad> Bod_Unidad_GetByLikeArticulo(Scope s,string Nombre, string Com_Articulo_Id)
    {
      return Bod_Unidad.GetByLikeArticulo(s,Nombre, Com_Articulo_Id);
    }
    [WebMethod]
    public List<Bod_Unidad> Bod_Unidad_GetByLikeNombre(Scope s, string Nombre)
    {
        return Bod_Unidad.GetByLikeNombre(s, Nombre);
    }
    [WebMethod]
    public List<Bod_Unidad> Bod_Unidad_GetByMultiplos(Scope s, string Bod_Unidad_Id)
    {
        return Bod_Unidad.GetByMultiplos(s, Bod_Unidad_Id);
    }
    [WebMethod]
    public List<Bod_Unidad> Bod_Unidad_GetByReferencia(Scope s)
    {
        return Bod_Unidad.GetByReferencia(s);
    }
    [WebMethod]
    public List<Bod_Unidad> Bod_Unidad_GetBySubmultiplos(Scope s, string Bod_Unidad_Id)
    {
        return Bod_Unidad.GetBySubmultiplos(s, Bod_Unidad_Id);
    }
    [WebMethod]
    public List<Bod_Unidad> Bod_Unidad_GetByGrupoUnidad(Scope s, string Bod_Unidad_Id)
      {
          return Bod_Unidad.GetByGrupoUnidad(s, Bod_Unidad_Id);
      }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Unidad
    /// <summary>
    /// Borra el objeto de Bod_Unidad
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Unidad_Delete(Scope s, Bod_Unidad o)
    {
        try
        {
            return Bod_Unidad.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Unidad
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Unidad_Insert(Scope s, Bod_Unidad o)
    {
        try
        {
            return Bod_Unidad.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Unidad
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Unidad_Update(Scope s, Bod_Unidad o, Bod_Unidad original)
    {
        try
        {
            return Bod_Unidad.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Alta_Motivo
    // Objeto permanente para acceso a DO_Bod_Alta_Motivo
    private DO_Bod_Alta_Motivo _Bod_Alta_Motivo;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Alta_Motivo
    /// </summary>
    public DO_Bod_Alta_Motivo Bod_Alta_Motivo
    {
        get
        {
            if (_Bod_Alta_Motivo == null)
                _Bod_Alta_Motivo = new DO_Bod_Alta_Motivo();
            return _Bod_Alta_Motivo;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Alta_Motivo> Bod_Alta_Motivo_Get(Scope s)
    {
        return Bod_Alta_Motivo.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Alta_Motivo
    /// </summary>
    /// <returns>Todos los registros de Bod_Alta_Motivo </returns>

    [WebMethod]
    public List<Bod_Alta_Motivo> Bod_Alta_Motivo_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Alta_Motivo.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Alta_Motivo> Bod_Alta_Motivo_GetByEmpresa(Scope s)
    {
        return Bod_Alta_Motivo.GetByEmpresa(s);
    }
    [WebMethod]
    public List<Bod_Alta_Motivo> Bod_Alta_Motivo_GetById(Scope s, string Id)
    {
        return Bod_Alta_Motivo.GetById(s, Id);
    }
    [WebMethod]
    public List<Bod_Alta_Motivo> Bod_Alta_Motivo_GetByLikeNombre(Scope s, string Nombre)
      {
          return Bod_Alta_Motivo.GetByLikeNombre(s, Nombre);
      }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Alta_Motivo
    /// <summary>
    /// Borra el objeto de Bod_Alta_Motivo
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Alta_Motivo_Delete(Scope s, Bod_Alta_Motivo o)
    {
        try
        {
            return Bod_Alta_Motivo.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Alta_Motivo
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Alta_Motivo_Insert(Scope s, Bod_Alta_Motivo o)
    {
        try
        {
            return Bod_Alta_Motivo.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Alta_Motivo
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Alta_Motivo_Update(Scope s, Bod_Alta_Motivo o, Bod_Alta_Motivo original)
    {
        try
        {
            return Bod_Alta_Motivo.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Baja_Motivo
    // Objeto permanente para acceso a DO_Bod_Baja_Motivo
    private DO_Bod_Baja_Motivo _Bod_Baja_Motivo;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Baja_Motivo
    /// </summary>
    public DO_Bod_Baja_Motivo Bod_Baja_Motivo
    {
        get
        {
            if (_Bod_Baja_Motivo == null)
                _Bod_Baja_Motivo = new DO_Bod_Baja_Motivo();
            return _Bod_Baja_Motivo;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Baja_Motivo> Bod_Baja_Motivo_Get(Scope s)
    {
        return Bod_Baja_Motivo.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Baja_Motivo
    /// </summary>
    /// <returns>Todos los registros de Bod_Baja_Motivo </returns>

    [WebMethod]
    public List<Bod_Baja_Motivo> Bod_Baja_Motivo_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Baja_Motivo.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Baja_Motivo> Bod_Baja_Motivo_GetByEmpresa(Scope s)
    {
        return Bod_Baja_Motivo.GetByEmpresa(s);
    }
    [WebMethod]
    public List<Bod_Baja_Motivo> Bod_Baja_Motivo_GetById(Scope s, string Id)
    {
        return Bod_Baja_Motivo.GetById(s, Id);
    }
    [WebMethod]
    public List<Bod_Baja_Motivo> Bod_Baja_Motivo_GetByLikeNombre(Scope s, string Nombre)
      {
          return Bod_Baja_Motivo.GetByLikeNombre(s, Nombre);
      }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Baja_Motivo
    /// <summary>
    /// Borra el objeto de Bod_Baja_Motivo
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Baja_Motivo_Delete(Scope s, Bod_Baja_Motivo o)
    {
        try
        {
            return Bod_Baja_Motivo.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Baja_Motivo
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Baja_Motivo_Insert(Scope s, Bod_Baja_Motivo o)
    {
        try
        {
            return Bod_Baja_Motivo.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Baja_Motivo
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Baja_Motivo_Update(Scope s, Bod_Baja_Motivo o, Bod_Baja_Motivo original)
    {
        try
        {
            return Bod_Baja_Motivo.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Archivo_Plano
    // Objeto permanente para acceso a DO_Bod_Archivo_Plano
    private DO_Bod_Archivo_Plano _Bod_Archivo_Plano;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Archivo_Plano
    /// </summary>
    public DO_Bod_Archivo_Plano Bod_Archivo_Plano
    {
        get
        {
            if (_Bod_Archivo_Plano == null)
                _Bod_Archivo_Plano = new DO_Bod_Archivo_Plano();
            return _Bod_Archivo_Plano;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Archivo_Plano> Bod_Archivo_Plano_Get(Scope s)
    {
        return Bod_Archivo_Plano.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Archivo_Plano
    /// </summary>
    /// <returns>Todos los registros de Bod_Archivo_Plano </returns>

    [WebMethod]
    public List<Bod_Archivo_Plano> Bod_Archivo_Plano_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Archivo_Plano.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Archivo_Plano> Bod_Archivo_Plano_GetByEmpresa(Scope s)
    {
        return Bod_Archivo_Plano.GetByEmpresa(s);
    }
    [WebMethod]
    public List<Bod_Archivo_Plano> Bod_Archivo_Plano_GetById(Scope s, string Id)
    {
        return Bod_Archivo_Plano.GetById(s, Id);
    }
      [WebMethod]
      public List<Bod_Archivo_Plano> Bod_Archivo_Plano_GetByConteo(Scope s, string Bod_Conteo_Fisico_Id)
      {
          return Bod_Archivo_Plano.GetByConteo(s, Bod_Conteo_Fisico_Id);
      }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Archivo_Plano
    /// <summary>
    /// Borra el objeto de Bod_Archivo_Plano
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Archivo_Plano_Delete(Scope s, Bod_Archivo_Plano o)
    {
        try
        {
            return DEL.BOD.DO_Bod_Archivo_Plano.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Archivo_Plano
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Archivo_Plano_Insert(Scope s, Bod_Archivo_Plano o)
    {
        try
        {
            return DEL.BOD.DO_Bod_Archivo_Plano.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Archivo_Plano
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Archivo_Plano_Update(Scope s, Bod_Archivo_Plano o, Bod_Archivo_Plano original)
    {
        try
        {
            return Bod_Archivo_Plano.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Archivo_Plano_Documento
    // Objeto permanente para acceso a DO_Bod_Archivo_Plano_Documento
    private DO_Bod_Archivo_Plano_Documento _Bod_Archivo_Plano_Documento;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Archivo_Plano_Documento
    /// </summary>
    public DO_Bod_Archivo_Plano_Documento Bod_Archivo_Plano_Documento
    {
        get
        {
            if (_Bod_Archivo_Plano_Documento == null)
                _Bod_Archivo_Plano_Documento = new DO_Bod_Archivo_Plano_Documento();
            return _Bod_Archivo_Plano_Documento;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Archivo_Plano_Documento> Bod_Archivo_Plano_Documento_Get(Scope s)
    {
        return Bod_Archivo_Plano_Documento.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Archivo_Plano_Documento
    /// </summary>
    /// <returns>Todos los registros de Bod_Archivo_Plano_Documento </returns>

    [WebMethod]
    public List<Bod_Archivo_Plano_Documento> Bod_Archivo_Plano_Documento_GetByArchivo(Scope s, string Bod_Archivo_Plano_Id)
    {
        return Bod_Archivo_Plano_Documento.GetByArchivo(s, Bod_Archivo_Plano_Id);
    }
    [WebMethod]
    public List<Bod_Archivo_Plano_Documento> Bod_Archivo_Plano_Documento_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Archivo_Plano_Documento.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Archivo_Plano_Documento> Bod_Archivo_Plano_Documento_GetById(Scope s, string Id)
    {
        return Bod_Archivo_Plano_Documento.GetById(s, Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Archivo_Plano_Documento
    /// <summary>
    /// Borra el objeto de Bod_Archivo_Plano_Documento
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Archivo_Plano_Documento_Delete(Scope s, Bod_Archivo_Plano_Documento o)
    {
        try
        {
            return Bod_Archivo_Plano_Documento.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Archivo_Plano_Documento
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Archivo_Plano_Documento_Insert(Scope s, Bod_Archivo_Plano_Documento o)
    {
        try
        {
            return Bod_Archivo_Plano_Documento.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Archivo_Plano_Documento
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Archivo_Plano_Documento_Update(Scope s, Bod_Archivo_Plano_Documento o, Bod_Archivo_Plano_Documento original)
    {
        try
        {
            return Bod_Archivo_Plano_Documento.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Archivo_Plano_Det
    // Objeto permanente para acceso a DO_Bod_Archivo_Plano_Det
    private DO_Bod_Archivo_Plano_Det _Bod_Archivo_Plano_Det;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Archivo_Plano_Det
    /// </summary>
    public DO_Bod_Archivo_Plano_Det Bod_Archivo_Plano_Det
    {
        get
        {
            if (_Bod_Archivo_Plano_Det == null)
                _Bod_Archivo_Plano_Det = new DO_Bod_Archivo_Plano_Det();
            return _Bod_Archivo_Plano_Det;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Archivo_Plano_Det> Bod_Archivo_Plano_Det_Get(Scope s)
    {
        return Bod_Archivo_Plano_Det.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Archivo_Plano_Det
    /// </summary>
    /// <returns>Todos los registros de Bod_Archivo_Plano_Det </returns>

    [WebMethod]
    public List<Bod_Archivo_Plano_Det> Bod_Archivo_Plano_Det_GetByArchivo(Scope s, string Bod_Archivo_Plano_Id)
    {
        return Bod_Archivo_Plano_Det.GetByArchivo(s, Bod_Archivo_Plano_Id);
    }
    [WebMethod]
    public List<Bod_Archivo_Plano_Det> Bod_Archivo_Plano_Det_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Archivo_Plano_Det.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Archivo_Plano_Det> Bod_Archivo_Plano_Det_GetById(Scope s, string Id)
    {
        return Bod_Archivo_Plano_Det.GetById(s, Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Archivo_Plano_Det
    /// <summary>
    /// Borra el objeto de Bod_Archivo_Plano_Det
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Archivo_Plano_Det_Delete(Scope s, Bod_Archivo_Plano_Det o)
    {
        try
        {
            return Bod_Archivo_Plano_Det.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Archivo_Plano_Det
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Archivo_Plano_Det_Insert(Scope s, Bod_Archivo_Plano_Det o)
    {
        try
        {
            return Bod_Archivo_Plano_Det.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Archivo_Plano_Det
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Archivo_Plano_Det_Update(Scope s, Bod_Archivo_Plano_Det o, Bod_Archivo_Plano_Det original)
    {
        try
        {
            return Bod_Archivo_Plano_Det.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Conteo_Fisico
    // Objeto permanente para acceso a DO_Bod_Conteo_Fisico
    private DO_Bod_Conteo_Fisico _Bod_Conteo_Fisico;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Conteo_Fisico
    /// </summary>
    public DO_Bod_Conteo_Fisico Bod_Conteo_Fisico
    {
        get
        {
            if (_Bod_Conteo_Fisico == null)
                _Bod_Conteo_Fisico = new DO_Bod_Conteo_Fisico();
            return _Bod_Conteo_Fisico;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Conteo_Fisico> Bod_Conteo_Fisico_Get(Scope s)
    {
        return Bod_Conteo_Fisico.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Conteo_Fisico
    /// </summary>
    /// <returns>Todos los registros de Bod_Conteo_Fisico </returns>

    [WebMethod]
    public List<Bod_Conteo_Fisico> Bod_Conteo_Fisico_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Conteo_Fisico.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Conteo_Fisico> Bod_Conteo_Fisico_GetByEmpresa(Scope s)
    {
        return DEL.BOD.DO_Bod_Conteo_Fisico.GetByEmpresa(s);
    }
    [WebMethod]
    public List<Bod_Conteo_Fisico> Bod_Conteo_Fisico_GetById(Scope s, string Id)
    {
        return Bod_Conteo_Fisico.GetById(s, Id);
    }
      [WebMethod]
      public List<Bod_Conteo_Fisico> Bod_Conteo_Fisico_GetByEstado(Scope s, string estado,string Bod_Bodega_Nombre, DateTime Fecha_Inicio,DateTime Fecha_Final)
      {
          return Bod_Conteo_Fisico.GetByEstado(s, estado, Bod_Bodega_Nombre,  Fecha_Inicio, Fecha_Final);
      }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Conteo_Fisico
    /// <summary>
    /// Borra el objeto de Bod_Conteo_Fisico
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Conteo_Fisico_Delete(Scope s, Bod_Conteo_Fisico o)
    {
        try
        {
            return Bod_Conteo_Fisico.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Conteo_Fisico
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Conteo_Fisico_Insert(Scope s, Bod_Conteo_Fisico o)
    {
        try
        {
            return Bod_Conteo_Fisico.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Conteo_Fisico
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Conteo_Fisico_Update(Scope s, Bod_Conteo_Fisico o, Bod_Conteo_Fisico original)
    {
        try
        {
            return Bod_Conteo_Fisico.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
      #endregion

    #region Servicios para Bod_Conteo_Fisico_Det
    // Objeto permanente para acceso a DO_Bod_Conteo_Fisico_Det
    private DO_Bod_Conteo_Fisico_Det _Bod_Conteo_Fisico_Det;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Conteo_Fisico_Det
    /// </summary>
    public DO_Bod_Conteo_Fisico_Det Bod_Conteo_Fisico_Det
    {
        get
        {
            if (_Bod_Conteo_Fisico_Det == null)
                _Bod_Conteo_Fisico_Det = new DO_Bod_Conteo_Fisico_Det();
            return _Bod_Conteo_Fisico_Det;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Conteo_Fisico_Det> Bod_Conteo_Fisico_Det_Get(Scope s)
    {
        return Bod_Conteo_Fisico_Det.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Conteo_Fisico_Det
    /// </summary>
    /// <returns>Todos los registros de Bod_Conteo_Fisico_Det </returns>

    [WebMethod]
    public List<Bod_Conteo_Fisico_Det> Bod_Conteo_Fisico_Det_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Conteo_Fisico_Det.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Conteo_Fisico_Det> Bod_Conteo_Fisico_Det_GetByConteo(Scope s, string Bod_Conteo_Fisico_Id)
    {
        return Bod_Conteo_Fisico_Det.GetByConteo(s, Bod_Conteo_Fisico_Id);
    }
    [WebMethod]
    public List<Bod_Conteo_Fisico_Det> Bod_Conteo_Fisico_Det_GetById(Scope s, string Id)
    {
        return Bod_Conteo_Fisico_Det.GetById(s, Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Conteo_Fisico_Det
    /// <summary>
    /// Borra el objeto de Bod_Conteo_Fisico_Det
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Conteo_Fisico_Det_Delete(Scope s, Bod_Conteo_Fisico_Det o)
    {
        try
        {
            return Bod_Conteo_Fisico_Det.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Conteo_Fisico_Det
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Conteo_Fisico_Det_Insert(Scope s, Bod_Conteo_Fisico_Det o)
    {
        try
        {
            return Bod_Conteo_Fisico_Det.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Conteo_Fisico_Det
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Conteo_Fisico_Det_Update(Scope s, Bod_Conteo_Fisico_Det o, Bod_Conteo_Fisico_Det original)
    {
        try
        {
            return Bod_Conteo_Fisico_Det.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Baja
    // Objeto permanente para acceso a DO_Bod_Baja
    private DO_Bod_Baja _Bod_Baja;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Baja
    /// </summary>
    public DO_Bod_Baja Bod_Baja
    {
        get
        {
            if (_Bod_Baja == null)
                _Bod_Baja = new DO_Bod_Baja();
            return _Bod_Baja;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Baja> Bod_Baja_Get(Scope s)
    {
        return Bod_Baja.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Baja
    /// </summary>
    /// <returns>Todos los registros de Bod_Baja </returns>

    [WebMethod]
    public List<Bod_Baja> Bod_Baja_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Baja.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Baja> Bod_Baja_GetByEmpresa(Scope s)
    {
        return DEL.BOD.DO_Bod_Baja.GetByEmpresa(s);
    }
    [WebMethod]
    public List<Bod_Baja> Bod_Baja_GetById(Scope s, string Id)
    {
        return Bod_Baja.GetById(s, Id);
    }
    [WebMethod]
      public List<Bod_Baja> Bod_Baja_GetByEstado(Scope s, string estado, string Bod_Bodega_Nombre, DateTime Fecha_Inicio, DateTime Fecha_Final) 
    {
      return Bod_Baja.GetByEstado(s, estado, Bod_Bodega_Nombre, Fecha_Inicio, Fecha_Final);
    } 
    #endregion
    #region  Operaciones con datos de la tabla Bod_Baja
    /// <summary>
    /// Borra el objeto de Bod_Baja
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Baja_Delete(Scope s, Bod_Baja o)
    {
        try
        {
            return Bod_Baja.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Baja
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Baja_Insert(Scope s, Bod_Baja o)
    {
        try
        {
            return Bod_Baja.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Baja
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Baja_Update(Scope s, Bod_Baja o, Bod_Baja original)
    {
        try
        {
            return Bod_Baja.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Alta
    // Objeto permanente para acceso a DO_Bod_Alta
    private DO_Bod_Alta _Bod_Alta;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Alta
    /// </summary>
    public DO_Bod_Alta Bod_Alta
    {
        get
        {
            if (_Bod_Alta == null)
                _Bod_Alta = new DO_Bod_Alta();
            return _Bod_Alta;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Alta> Bod_Alta_Get(Scope s)
    {
        return Bod_Alta.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Alta
    /// </summary>
    /// <returns>Todos los registros de Bod_Alta </returns>

    [WebMethod]
    public List<Bod_Alta> Bod_Alta_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Alta.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Alta> Bod_Alta_GetByEmpresa(Scope s)
    {
        return DEL.BOD.DO_Bod_Alta.GetByEmpresa(s);
    }
    [WebMethod]
    public List<Bod_Alta> Bod_Alta_GetById(Scope s, string Id)
    {
        return Bod_Alta.GetById(s, Id);
    }

      [WebMethod]
      public List<Bod_Alta> Bod_Alta_GetByEstado(Scope s, string Estado, string Bod_Bodega_Nombre, DateTime Fecha_Inicio, DateTime Fecha_Final)
      {
          return Bod_Alta.GetByEstado(s, Estado, Bod_Bodega_Nombre, Fecha_Inicio, Fecha_Final);
      }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Alta
    /// <summary>
    /// Borra el objeto de Bod_Alta
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Alta_Delete(Scope s, Bod_Alta o)
    {
        try
        {
            return Bod_Alta.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Alta
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Alta_Insert(Scope s, Bod_Alta o)
    {
        try
        {
            return Bod_Alta.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Alta
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Alta_Update(Scope s, Bod_Alta o, Bod_Alta original)
    {
        try
        {
            return Bod_Alta.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Alta_det
    // Objeto permanente para acceso a DO_Bod_Alta_det
    private DO_Bod_Alta_det _Bod_Alta_det;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Alta_det
    /// </summary>
    public DO_Bod_Alta_det Bod_Alta_det
    {
        get
        {
            if (_Bod_Alta_det == null)
                _Bod_Alta_det = new DO_Bod_Alta_det();
            return _Bod_Alta_det;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Alta_det> Bod_Alta_det_Get(Scope s)
    {
        return Bod_Alta_det.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Alta_det
    /// </summary>
    /// <returns>Todos los registros de Bod_Alta_det </returns>

    [WebMethod]
    public List<Bod_Alta_det> Bod_Alta_det_GetByAlta(Scope s, string Bod_Alta_Id)
    {
        return Bod_Alta_det.GetByAlta(s, Bod_Alta_Id);
    }
    [WebMethod]
    public List<Bod_Alta_det> Bod_Alta_det_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Alta_det.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Alta_det> Bod_Alta_det_GetById(Scope s, string Id)
    {
        return Bod_Alta_det.GetById(s, Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Alta_det
    /// <summary>
    /// Borra el objeto de Bod_Alta_det
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Alta_det_Delete(Scope s, Bod_Alta_det o)
    {
        try
        {
            return Bod_Alta_det.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Alta_det
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Alta_det_Insert(Scope s, Bod_Alta_det o)
    {
        try
        {
            return Bod_Alta_det.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Alta_det
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Alta_det_Update(Scope s, Bod_Alta_det o, Bod_Alta_det original)
    {
        try
        {
            return Bod_Alta_det.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Baja_Det
    // Objeto permanente para acceso a DO_Bod_Baja_Det
    private DO_Bod_Baja_Det _Bod_Baja_Det;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Baja_Det
    /// </summary>
    public DO_Bod_Baja_Det Bod_Baja_Det
    {
        get
        {
            if (_Bod_Baja_Det == null)
                _Bod_Baja_Det = new DO_Bod_Baja_Det();
            return _Bod_Baja_Det;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Baja_Det> Bod_Baja_Det_Get(Scope s)
    {
        return Bod_Baja_Det.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Baja_Det
    /// </summary>
    /// <returns>Todos los registros de Bod_Baja_Det </returns>

    [WebMethod]
    public List<Bod_Baja_Det> Bod_Baja_Det_GetByBaja(Scope s, string Bod_Baja_Id)
    {
        return Bod_Baja_Det.GetByBaja(s, Bod_Baja_Id);
    }
    [WebMethod]
    public List<Bod_Baja_Det> Bod_Baja_Det_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Baja_Det.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Baja_Det> Bod_Baja_Det_GetById(Scope s, string Id)
    {
        return Bod_Baja_Det.GetById(s, Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Baja_Det
    /// <summary>
    /// Borra el objeto de Bod_Baja_Det
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Baja_Det_Delete(Scope s, Bod_Baja_Det o)
    {
        try
        {
            return Bod_Baja_Det.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Baja_Det
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Baja_Det_Insert(Scope s, Bod_Baja_Det o)
    {
        try
        {
            return Bod_Baja_Det.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Baja_Det
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Baja_Det_Update(Scope s, Bod_Baja_Det o, Bod_Baja_Det original)
    {
        try
        {
            return Bod_Baja_Det.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Bodega_Subperiodo
    // Objeto permanente para acceso a DO_Bod_Bodega_Subperiodo
    private DO_Bod_Bodega_Subperiodo _Bod_Bodega_Subperiodo;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Bodega_Subperiodo
    /// </summary>
    public DO_Bod_Bodega_Subperiodo Bod_Bodega_Subperiodo
    {
        get
        {
            if (_Bod_Bodega_Subperiodo == null)
                _Bod_Bodega_Subperiodo = new DO_Bod_Bodega_Subperiodo();
            return _Bod_Bodega_Subperiodo;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Bodega_Subperiodo> Bod_Bodega_Subperiodo_Get(Scope s)
    {
        return Bod_Bodega_Subperiodo.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Bodega_Subperiodo
    /// </summary>
    /// <returns>Todos los registros de Bod_Bodega_Subperiodo </returns>

    [WebMethod]
    public List<Bod_Bodega_Subperiodo> Bod_Bodega_Subperiodo_GetByBodega(Scope s, string Bod_Bodega_Id)
    {
        return Bod_Bodega_Subperiodo.GetByBodega(s, Bod_Bodega_Id);
    }
    [WebMethod]
    public List<Bod_Bodega_Subperiodo> Bod_Bodega_Subperiodo_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Bodega_Subperiodo.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Bodega_Subperiodo> Bod_Bodega_Subperiodo_GetById(Scope s, string Id)
    {
        return Bod_Bodega_Subperiodo.GetById(s, Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Bodega_Subperiodo
    /// <summary>
    /// Borra el objeto de Bod_Bodega_Subperiodo
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Bodega_Subperiodo_Delete(Scope s, Bod_Bodega_Subperiodo o)
    {
        try
        {
            return Bod_Bodega_Subperiodo.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Bodega_Subperiodo
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Bodega_Subperiodo_Insert(Scope s, Bod_Bodega_Subperiodo o)
    {
        try
        {
            return Bod_Bodega_Subperiodo.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Bodega_Subperiodo
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Bodega_Subperiodo_Update(Scope s, Bod_Bodega_Subperiodo o, Bod_Bodega_Subperiodo original)
    {
        try
        {
            return Bod_Bodega_Subperiodo.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Kardex
    // Objeto permanente para acceso a DO_Bod_Kardex
    private DO_Bod_Kardex _Bod_Kardex;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Kardex
    /// </summary>
    public DO_Bod_Kardex Bod_Kardex
    {
        get
        {
            if (_Bod_Kardex == null)
                _Bod_Kardex = new DO_Bod_Kardex();
            return _Bod_Kardex;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Kardex> Bod_Kardex_Get(Scope s)
    {
        return Bod_Kardex.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Kardex
    /// </summary>
    /// <returns>Todos los registros de Bod_Kardex </returns>

    [WebMethod]
    public List<Bod_Kardex> Bod_Kardex_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Kardex.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Kardex> Bod_Kardex_GetById(Scope s, string Id)
    {
        return Bod_Kardex.GetById(s, Id);
    }
    [WebMethod]
    public List<Bod_Kardex> Bod_Kardex_GetByStockActual(Scope s,string Bod_Bodega_Id,string Com_Articulo_Id, DateTime Fecha)
    {
      return Bod_Kardex.GetByStockActual(s,Bod_Bodega_Id, Com_Articulo_Id, Fecha);
    }
    [WebMethod]
    public List<Bod_Kardex> Bod_Kardex_GetByConsultar(Scope s, string Bod_Bodega_Id, string Com_Articulo_Id,string Bod_Unidad_Id,DateTime Fecha_Inicial, DateTime Fecha_Final)
    {
    return Bod_Kardex.GetByConsultar(s,Bod_Bodega_Id,Com_Articulo_Id,Bod_Unidad_Id,Fecha_Inicial, Fecha_Final);
    }
    [WebMethod]
    public List< Bod_Kardex> Bod_Kardex_GetByKardex ( Scope s, string Id, string Bod_Bodega_Id, string Com_Articulo_Id, string Update_Per_Personal_Id,string Estado)
    {
    return Bod_Kardex.GetByKardex(s,Id,Bod_Bodega_Id, Com_Articulo_Id,Update_Per_Personal_Id,Estado);
    }
    [WebMethod]
    public List< Bod_Kardex> Bod_Kardex_GetByNueva_Secuencia_Delete ( Scope s,string Bod_Bodega_Id,string Com_Articulo_Id,int Secuencia)
    {
    return Bod_Kardex.GetByNueva_Secuencia_Delete(s,Bod_Bodega_Id,Com_Articulo_Id, Secuencia );
    }
    [WebMethod]
    public List< Bod_Kardex> Bod_Kardex_GetByNueva_Secuencia_Insert ( Scope s,string Bod_Bodega_Id,string Com_Articulo_Id, int Secuencia)
    {
    return Bod_Kardex.GetByNueva_Secuencia_Insert(s,Bod_Bodega_Id,Com_Articulo_Id, Secuencia );
    }
    [WebMethod]
    public List< Bod_Kardex> Bod_Kardex_GetByUpdate_Kardex ( Scope s,string Id,int Secuencia,decimal Stock,string Int_Empresa_Id,string Bod_Bodega_Id,string Com_Articulo_Id,string Update_Per_Personal_Id)
    {
    return Bod_Kardex.GetByUpdate_Kardex(s,Id,Secuencia,Stock,Int_Empresa_Id,Bod_Bodega_Id,Com_Articulo_Id,Update_Per_Personal_Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Kardex
    /// <summary>
    /// Borra el objeto de Bod_Kardex
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Kardex_Delete(Scope s, Bod_Kardex o)
    {
        try
        {
            return Bod_Kardex.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Kardex
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Kardex_Insert(Scope s, Bod_Kardex o)
    {
        try
        {
            return Bod_Kardex.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Kardex
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Kardex_Update(Scope s, Bod_Kardex o, Bod_Kardex original)
    {
        try
        {
            return Bod_Kardex.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Orden
    // Objeto permanente para acceso a DO_Bod_Orden
    private DO_Bod_Orden _Bod_Orden;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Orden
    /// </summary>
    public DO_Bod_Orden Bod_Orden
    {
        get
        {
            if (_Bod_Orden == null)
                _Bod_Orden = new DO_Bod_Orden();
            return _Bod_Orden;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Orden> Bod_Orden_Get(Scope s)
    {
        return Bod_Orden.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Orden
    /// </summary>
    /// <returns>Todos los registros de Bod_Orden </returns>

    [WebMethod]
    public List<Bod_Orden> Bod_Orden_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Orden.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Orden> Bod_Orden_GetById(Scope s, string Id)
    {
        return Bod_Orden.GetById(s, Id);
    }
    [WebMethod]
    public List<Bod_Orden> Bod_Orden_GetByConteoFisico(Scope s, string Objeto_Id)
    {
      return Bod_Orden.GetByConteoFisico(s, Objeto_Id);
    }
      [WebMethod]
      public List<Bod_Orden> Bod_Orden_GetByOrigenOrigenId(Scope s, string Origen, string Origen_Id)
      {
          return Bod_Orden.GetByOrigenOrigenId(s,Origen, Origen_Id);
      }
      [WebMethod]
      public List<Bod_Orden> Bod_Orden_GetBySinKardex(Scope s, string Bod_Bodega_Id)
      {
          return Bod_Orden.GetBySinKardex(s, Bod_Bodega_Id);
      }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Orden
    /// <summary>
    /// Borra el objeto de Bod_Orden
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Orden_Delete(Scope s, Bod_Orden o)
    {
        try
        {
            return Bod_Orden.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Orden
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Orden_Insert(Scope s, Bod_Orden o)
    {
        try
        {
            return Bod_Orden.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Orden
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Orden_Update(Scope s, Bod_Orden o, Bod_Orden original)
    {
        try
        {
            return Bod_Orden.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Transferencia
    // Objeto permanente para acceso a DO_Bod_Transferencia
    private DO_Bod_Transferencia _Bod_Transferencia;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Transferencia
    /// </summary>
    public DO_Bod_Transferencia Bod_Transferencia
    {
        get
        {
            if (_Bod_Transferencia == null)
                _Bod_Transferencia = new DO_Bod_Transferencia();
            return _Bod_Transferencia;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Transferencia> Bod_Transferencia_Get(Scope s)
    {
        return Bod_Transferencia.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Transferencia
    /// </summary>
    /// <returns>Todos los registros de Bod_Transferencia </returns>

    [WebMethod]
    public List<Bod_Transferencia> Bod_Transferencia_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Transferencia.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Transferencia> Bod_Transferencia_GetByEmpresa(Scope s)
    {
        return Bod_Transferencia.GetByEmpresa(s);
    }
    [WebMethod]
    public List<Bod_Transferencia> Bod_Transferencia_GetById(Scope s, string Id)
    {
        return Bod_Transferencia.GetById(s, Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Transferencia
    /// <summary>
    /// Borra el objeto de Bod_Transferencia
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Transferencia_Delete(Scope s, Bod_Transferencia o)
    {
        try
        {
            return Bod_Transferencia.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Transferencia
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Transferencia_Insert(Scope s, Bod_Transferencia o)
    {
        try
        {
            return Bod_Transferencia.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Transferencia
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Transferencia_Update(Scope s, Bod_Transferencia o, Bod_Transferencia original)
    {
        try
        {
            return Bod_Transferencia.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Transferencia_Det
    // Objeto permanente para acceso a DO_Bod_Transferencia_Det
    private DO_Bod_Transferencia_Det _Bod_Transferencia_Det;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Transferencia_Det
    /// </summary>
    public DO_Bod_Transferencia_Det Bod_Transferencia_Det
    {
        get
        {
            if (_Bod_Transferencia_Det == null)
                _Bod_Transferencia_Det = new DO_Bod_Transferencia_Det();
            return _Bod_Transferencia_Det;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Transferencia_Det> Bod_Transferencia_Det_Get(Scope s)
    {
        return Bod_Transferencia_Det.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Transferencia_Det
    /// </summary>
    /// <returns>Todos los registros de Bod_Transferencia_Det </returns>

    [WebMethod]
    public List<Bod_Transferencia_Det> Bod_Transferencia_Det_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Transferencia_Det.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Transferencia_Det> Bod_Transferencia_Det_GetById(Scope s, string Id)
    {
        return Bod_Transferencia_Det.GetById(s, Id);
    }
    [WebMethod]
    public List<Bod_Transferencia_Det> Bod_Transferencia_Det_GetByTransferencia(Scope s, string Bod_Transferencia_Id)
    {
        return Bod_Transferencia_Det.GetByTransferencia(s, Bod_Transferencia_Id);
    }
    [WebMethod]
      public List<Bod_Transferencia_Det> Bod_Transferencia_Det_GetByLikeCodigoArticulo(Scope s, string Bod_Transferencia_Id, string Codigo)
    {
        return Bod_Transferencia_Det.GetByLikeCodigoArticulo(s,Bod_Transferencia_Id, Codigo);
    }
    [WebMethod]
      public List<Bod_Transferencia_Det> Bod_Transferencia_Det_GetByLikeNombreArticulo(Scope s, string Bod_Transferencia_Id, string Nombre)
    {
        return Bod_Transferencia_Det.GetByLikeNombreArticulo(s, Bod_Transferencia_Id, Nombre);
    }
    [WebMethod]
    public List<Bod_Transferencia_Det> Bod_Transferencia_Det_GetByDespacho(Scope s, string Bod_Transferencia_Id)
    {
      return Bod_Transferencia_Det.GetByDespacho(s, Bod_Transferencia_Id);
    } 
    #endregion
    #region  Operaciones con datos de la tabla Bod_Transferencia_Det
    /// <summary>
    /// Borra el objeto de Bod_Transferencia_Det
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Transferencia_Det_Delete(Scope s, Bod_Transferencia_Det o)
    {
        try
        {
            return Bod_Transferencia_Det.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Transferencia_Det
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Transferencia_Det_Insert(Scope s, Bod_Transferencia_Det o)
    {
        try
        {
            return Bod_Transferencia_Det.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Transferencia_Det
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Transferencia_Det_Update(Scope s, Bod_Transferencia_Det o, Bod_Transferencia_Det original)
    {
        try
        {
            return Bod_Transferencia_Det.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Transferencia_Despacho
    // Objeto permanente para acceso a DO_Bod_Transferencia_Despacho
    private DO_Bod_Transferencia_Despacho _Bod_Transferencia_Despacho;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Transferencia_Despacho
    /// </summary>
    public DO_Bod_Transferencia_Despacho Bod_Transferencia_Despacho
    {
        get
        {
            if (_Bod_Transferencia_Despacho == null)
                _Bod_Transferencia_Despacho = new DO_Bod_Transferencia_Despacho();
            return _Bod_Transferencia_Despacho;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Transferencia_Despacho> Bod_Transferencia_Despacho_Get(Scope s)
    {
        return Bod_Transferencia_Despacho.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Transferencia_Despacho
    /// </summary>
    /// <returns>Todos los registros de Bod_Transferencia_Despacho </returns>

    [WebMethod]
    public List<Bod_Transferencia_Despacho> Bod_Transferencia_Despacho_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Transferencia_Despacho.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Transferencia_Despacho> Bod_Transferencia_Despacho_GetByEmpresa(Scope s)
    {
        return Bod_Transferencia_Despacho.GetByEmpresa(s);
    }
    [WebMethod]
    public List<Bod_Transferencia_Despacho> Bod_Transferencia_Despacho_GetById(Scope s, string Id)
    {
        return Bod_Transferencia_Despacho.GetById(s, Id);
    }
    [WebMethod]
    public List<Bod_Transferencia_Despacho> Bod_Transferencia_Despacho_GetByTransferencia(Scope s, string Bod_Transferencia_Id)
    {
        return Bod_Transferencia_Despacho.GetByTransferencia(s, Bod_Transferencia_Id);
    }
    [WebMethod]
      public List<Bod_Transferencia_Despacho> Bod_Transferencia_Despacho_GetByEstado(Scope s, string estado, string Bod_Bodega_Nombre, DateTime Fecha_Inicio, DateTime Fecha_Final)
    {
    return Bod_Transferencia_Despacho.GetByEstado(s, estado, Bod_Bodega_Nombre, Fecha_Inicio, Fecha_Final);
    }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Transferencia_Despacho
    /// <summary>
    /// Borra el objeto de Bod_Transferencia_Despacho
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Transferencia_Despacho_Delete(Scope s, Bod_Transferencia_Despacho o)
    {
        try
        {
            return DEL.BOD.DO_Bod_Transferencia_Despacho.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Transferencia_Despacho
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Transferencia_Despacho_Insert(Scope s, Bod_Transferencia_Despacho o)
    {
        try
        {
            return DEL.BOD.DO_Bod_Transferencia_Despacho.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Transferencia_Despacho
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Transferencia_Despacho_Update(Scope s, Bod_Transferencia_Despacho o, Bod_Transferencia_Despacho original)
    {
        try
        {
            return Bod_Transferencia_Despacho.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Transferencia_Despacho_Det
    // Objeto permanente para acceso a DO_Bod_Transferencia_Despacho_Det
    private DO_Bod_Transferencia_Despacho_Det _Bod_Transferencia_Despacho_Det;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Transferencia_Despacho_Det
    /// </summary>
    public DO_Bod_Transferencia_Despacho_Det Bod_Transferencia_Despacho_Det
    {
        get
        {
            if (_Bod_Transferencia_Despacho_Det == null)
                _Bod_Transferencia_Despacho_Det = new DO_Bod_Transferencia_Despacho_Det();
            return _Bod_Transferencia_Despacho_Det;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Transferencia_Despacho_Det> Bod_Transferencia_Despacho_Det_Get(Scope s)
    {
        return Bod_Transferencia_Despacho_Det.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Transferencia_Despacho_Det
    /// </summary>
    /// <returns>Todos los registros de Bod_Transferencia_Despacho_Det </returns>

    [WebMethod]
    public List<Bod_Transferencia_Despacho_Det> Bod_Transferencia_Despacho_Det_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Transferencia_Despacho_Det.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Transferencia_Despacho_Det> Bod_Transferencia_Despacho_Det_GetByDespacho(Scope s, string Bod_Transferencia_Despacho_Id)
    {
        return Bod_Transferencia_Despacho_Det.GetByDespacho(s, Bod_Transferencia_Despacho_Id);
    }
    [WebMethod]
    public List<Bod_Transferencia_Despacho_Det> Bod_Transferencia_Despacho_Det_GetById(Scope s, string Id)
    {
        return Bod_Transferencia_Despacho_Det.GetById(s, Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Transferencia_Despacho_Det
    /// <summary>
    /// Borra el objeto de Bod_Transferencia_Despacho_Det
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Transferencia_Despacho_Det_Delete(Scope s, Bod_Transferencia_Despacho_Det o)
    {
        try
        {
            return Bod_Transferencia_Despacho_Det.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Transferencia_Despacho_Det
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Transferencia_Despacho_Det_Insert(Scope s, Bod_Transferencia_Despacho_Det o)
    {
        try
        {
            return Bod_Transferencia_Despacho_Det.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Transferencia_Despacho_Det
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Transferencia_Despacho_Det_Update(Scope s, Bod_Transferencia_Despacho_Det o, Bod_Transferencia_Despacho_Det original)
    {
        try
        {
            return Bod_Transferencia_Despacho_Det.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Transferencia_Recepcion
    // Objeto permanente para acceso a DO_Bod_Transferencia_Recepcion
    private DO_Bod_Transferencia_Recepcion _Bod_Transferencia_Recepcion;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Transferencia_Recepcion
    /// </summary>
    public DO_Bod_Transferencia_Recepcion Bod_Transferencia_Recepcion
    {
        get
        {
            if (_Bod_Transferencia_Recepcion == null)
                _Bod_Transferencia_Recepcion = new DO_Bod_Transferencia_Recepcion();
            return _Bod_Transferencia_Recepcion;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Transferencia_Recepcion> Bod_Transferencia_Recepcion_Get(Scope s)
    {
        return Bod_Transferencia_Recepcion.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Transferencia_Recepcion
    /// </summary>
    /// <returns>Todos los registros de Bod_Transferencia_Recepcion </returns>

    [WebMethod]
    public List<Bod_Transferencia_Recepcion> Bod_Transferencia_Recepcion_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Transferencia_Recepcion.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Transferencia_Recepcion> Bod_Transferencia_Recepcion_GetByEmpresa(Scope s)
    {
        return Bod_Transferencia_Recepcion.GetByEmpresa(s);
    }
    [WebMethod]
    public List<Bod_Transferencia_Recepcion> Bod_Transferencia_Recepcion_GetById(Scope s, string Id)
    {
        return Bod_Transferencia_Recepcion.GetById(s, Id);
    }
    [WebMethod]
    public List<Bod_Transferencia_Recepcion> Bod_Transferencia_Recepcion_GetByTransferencia(Scope s, string Bod_Transferencia_Id)
    {
        return Bod_Transferencia_Recepcion.GetByTransferencia(s, Bod_Transferencia_Id);
    }
    [WebMethod]
      public List<Bod_Transferencia_Recepcion> Bod_Transferencia_Recepcion_GetByEstado(Scope s, string estado, string Bod_Bodega_Nombre, DateTime Fecha_Inicio, DateTime Fecha_Final)
    {
      return Bod_Transferencia_Recepcion.GetByEstado(s, estado, Bod_Bodega_Nombre, Fecha_Inicio, Fecha_Final);
    }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Transferencia_Recepcion
    /// <summary>
    /// Borra el objeto de Bod_Transferencia_Recepcion
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Transferencia_Recepcion_Delete(Scope s, Bod_Transferencia_Recepcion o)
    {
        try
        {
            return Bod_Transferencia_Recepcion.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Transferencia_Recepcion
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Transferencia_Recepcion_Insert(Scope s, Bod_Transferencia_Recepcion o)
    {
        try
        {
            return Bod_Transferencia_Recepcion.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Transferencia_Recepcion
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Transferencia_Recepcion_Update(Scope s, Bod_Transferencia_Recepcion o, Bod_Transferencia_Recepcion original)
    {
        try
        {
            return Bod_Transferencia_Recepcion.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Transferencia_Recepcion_Det
    // Objeto permanente para acceso a DO_Bod_Transferencia_Recepcion_Det
    private DO_Bod_Transferencia_Recepcion_Det _Bod_Transferencia_Recepcion_Det;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Transferencia_Recepcion_Det
    /// </summary>
    public DO_Bod_Transferencia_Recepcion_Det Bod_Transferencia_Recepcion_Det
    {
        get
        {
            if (_Bod_Transferencia_Recepcion_Det == null)
                _Bod_Transferencia_Recepcion_Det = new DO_Bod_Transferencia_Recepcion_Det();
            return _Bod_Transferencia_Recepcion_Det;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Bod_Transferencia_Recepcion_Det> Bod_Transferencia_Recepcion_Det_Get(Scope s)
    {
        return Bod_Transferencia_Recepcion_Det.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Transferencia_Recepcion_Det
    /// </summary>
    /// <returns>Todos los registros de Bod_Transferencia_Recepcion_Det </returns>

    [WebMethod]
    public List<Bod_Transferencia_Recepcion_Det> Bod_Transferencia_Recepcion_Det_GetByCodigo(Scope s, string Codigo)
    {
        return Bod_Transferencia_Recepcion_Det.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Bod_Transferencia_Recepcion_Det> Bod_Transferencia_Recepcion_Det_GetById(Scope s, string Id)
    {
        return Bod_Transferencia_Recepcion_Det.GetById(s, Id);
    }
    [WebMethod]
    public List<Bod_Transferencia_Recepcion_Det> Bod_Transferencia_Recepcion_Det_GetByRecepcion(Scope s, string Bod_Transferencia_Recepcion_Id)
    {
        return Bod_Transferencia_Recepcion_Det.GetByRecepcion(s, Bod_Transferencia_Recepcion_Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Bod_Transferencia_Recepcion_Det
    /// <summary>
    /// Borra el objeto de Bod_Transferencia_Recepcion_Det
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Bod_Transferencia_Recepcion_Det_Delete(Scope s, Bod_Transferencia_Recepcion_Det o)
    {
        try
        {
            return Bod_Transferencia_Recepcion_Det.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Bod_Transferencia_Recepcion_Det
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Bod_Transferencia_Recepcion_Det_Insert(Scope s, Bod_Transferencia_Recepcion_Det o)
    {
        try
        {
            return Bod_Transferencia_Recepcion_Det.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Bod_Transferencia_Recepcion_Det
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Bod_Transferencia_Recepcion_Det_Update(Scope s, Bod_Transferencia_Recepcion_Det o, Bod_Transferencia_Recepcion_Det original)
    {
        try
        {
            return Bod_Transferencia_Recepcion_Det.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Bod_Movimiento
    // Objeto permanente para acceso a DO_Bod_Movimiento
    private DO_Bod_Movimiento _Bod_Movimiento;
    /// <summary>
    /// La propiedad para acceso a DO_Bod_Movimiento
    /// </summary>
    public DO_Bod_Movimiento Bod_Movimiento
    {
        get
        {
            if (_Bod_Movimiento == null)
                _Bod_Movimiento = new DO_Bod_Movimiento();
            return _Bod_Movimiento;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
      public List<Bod_Movimiento> Bod_Movimiento_Get(Scope s, string Bod_Bodega_Id, DateTime Fecha_Inicial, DateTime Fecha_Final)
    {
        return Bod_Movimiento.Get(s,Bod_Bodega_Id,Fecha_Inicial, Fecha_Final);
    }
    /// <summary>
    /// Retorna todos los datos de Bod_Movimiento
    /// </summary>
    /// <returns>Todos los registros de Bod_Movimiento </returns>

    #endregion
    
    #endregion
    }
  }
  
